package com.book.service.impl;

import com.book.dao.CartDao;
import com.book.dao.OrderDao;
import com.book.dto.CartDto;
import com.book.entity.Cart;
import com.book.entity.Order;
import com.book.service.CartService;
import com.book.utils.ResponseResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.Instant;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

//购物车自定义错误状态码2001开始
@Service
public class CartServiceImpl implements CartService {
    @Autowired
    private CartDao cartDao;

    @Autowired
    private OrderDao orderDao;

    private static Integer i = 1;

    @Override
    public ResponseResult addCart(Cart cart) {
//        TimeZone.setDefault(TimeZone.getTimeZone("GMT+8"));
        cart.setCreateTime(new Date());//设置创建购物车的时间
//        System.out.println(cart);
        try {
            cartDao.insert(cart);
            return new ResponseResult(200,"添加成功");
        }catch (Exception e){
            return new ResponseResult(2001,"添加失败"+e.getMessage());
        }
    }

    @Transactional//确保事务管理，因为这里需要删除多个数据
    @Override
    public ResponseResult deleteCartByIds(List<Integer> cartIds) {

        if(cartDao.deleteBatchIds(cartIds) == cartIds.size())
            return new ResponseResult(200,"批量删除成功");
        else return new ResponseResult(2002,"批量删除失败");
    }

    @Override
    public ResponseResult getCarts(String userId) {
        try {
            List<CartDto> cartDtos = cartDao.selectAllCarts(userId);
            return new ResponseResult(200,"查询购物车成功",cartDtos);
        }catch (Exception e){
            return new ResponseResult(2003,"查询购物车失败:"+e.getMessage());
        }
    }

    @Override
    public ResponseResult deleteCartById(int id) {
        try {
            cartDao.deleteById(id);
            return new ResponseResult(200,"删除成功");
        }catch (Exception e){
            return new ResponseResult(2005,"删除失败："+e.getMessage());
        }
    }

    /**
     *
     * @param addressId 地址Id
     * @param cartIds 购物车id列表
     * @return
     */
    //引入事务就别捕获异常，不然事务会失效
    @Transactional//确保事务管理，因为这里需要同时购买多个购物车，如果购买成功同时还要批量删除购物车
    @Override
    public ResponseResult buyCartByIds(int addressId, List<Integer> cartIds) {
        ArrayList<Order> orderArrayList = new ArrayList<>();
        List<Cart> cartList = cartDao.selectBatchIds(cartIds);//根据传来的购物车id数组查询要被购买的购物车信息
        AtomicInteger flag1 = new AtomicInteger();
        cartList.forEach(cart -> {
            Order order = new Order();
            synchronized(i){//同步代码块，确保同一个时间只有一个线程在创建一个订单id和时间
                long l = Instant.now().toEpochMilli();//1970年1月1日 00:00:00 UTC开始到现在的时间戳
                order.setId("FY"+l+String.format("%04d", i++));
                if(i>9999) i = 1;
            }
            order.setBookId(cart.getBookId());//赋值书籍id
            order.setUserId(cart.getUserId());//赋值用户id
            order.setOrderTime(new Date());//设置订单创建时间
            order.setAddressId(addressId);//设置地址
            order.setAmount(cart.getAmount());//设置订单种数量为购物车中的书籍数量
            order.setPrice(cart.getPrice());//设置订单中价格位购物车中的价格
            orderArrayList.add(order);
            flag1.getAndIncrement();
        });
        //然后添加进入订单表中
        AtomicInteger flag2 = new AtomicInteger();
        orderArrayList.forEach(order -> {
            orderDao.insert(order);
            flag2.getAndIncrement();
        });
        cartDao.deleteBatchIds(cartIds);//然后删除掉原来的购物车信息
        if(cartList.size() == cartIds.size() && flag1.get() == cartList.size() && flag2.get() ==  orderArrayList.size())
            return new ResponseResult(200,"批量购买成功,感谢您的支持!");
        else return new ResponseResult(2007,"批量购买失败");
    }

    /**
     *
     * @param addressId 地址id
     * @param id 购物车id
     * @return
     */
    @Transactional//确保事务管理，因为这里需要先购买购物车，然后添加进入订单表中，然后再删除购物车
    @Override
    public ResponseResult buyCartById(int addressId, int id) {
        Cart cart = cartDao.selectById(id);
        Order order = new Order();
        synchronized(i){//同步代码块，确保同一个时间只有一个线程在创建一个订单id和时间
            long l = Instant.now().toEpochMilli();//1970年1月1日 00:00:00 UTC开始到现在的时间戳
            order.setId("FY"+l+String.format("%04d", i++));
            if(i>9999) i = 1;
        }
        order.setBookId(cart.getBookId());//赋值书籍id
        order.setUserId(cart.getUserId());//赋值用户id
        order.setOrderTime(new Date());//设置订单创建时间
        order.setAddressId(addressId);//设置地址
        order.setAmount(cart.getAmount());//设置订单种数量为购物车中的书籍数量
        order.setPrice(cart.getPrice());//设置订单中价格位购物车中的价格
        int flag1 = orderDao.insert(order);//购买就是在订单表中生成一行订单
        int flag2 = cartDao.deleteById(id);//然后删除购物车种对应的表
        if(flag1 == flag2)
            return new ResponseResult(200,"购买成功,感谢您的支持");
        else return new ResponseResult(2008,"购买失败");

    }

    @Override
    public ResponseResult buyDirectly(Cart cart,int addressId) {//传来了一个个购物车，和地址id
        try {
//            System.out.println(cart);
            Order order = new Order();
            synchronized(i){//同步代码块，确保同一个时间只有一个线程在创建一个订单id和时间
                long l = Instant.now().toEpochMilli();//1970年1月1日 00:00:00 UTC开始到现在的时间戳
                order.setId("FY"+l+String.format("%04d", i++));
                if(i>9999) i = 1;
            }
            order.setBookId(cart.getBookId());//赋值书籍id
            order.setUserId(cart.getUserId());//赋值用户id
            order.setOrderTime(new Date());//设置订单创建时间
            order.setAddressId(addressId);//设置地址
            order.setAmount(cart.getAmount());//设置订单中的数量为购物车中的书籍数量
            order.setPrice(cart.getPrice());//设置订单中价格为购物车中的价格
            orderDao.insert(order);
            return new ResponseResult(200,"购买成功，购物愉快!");
        }catch (Exception e){
            return new ResponseResult(2009,"直接购买失败："+e.getMessage());
        }
    }
}
